package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern void nav_dtBVNode_Delete(void * c_this);
extern void nav_dtBVNode_DeleteArray(void * c_this);
extern void* nav_NewdtBVNode();
extern void * nav_dtBVNode_GetPtrToBmax(void * c_this);
extern void * nav_dtBVNode_GetPtrToBmin(void * c_this);
extern void * nav_dtBVNode_GetPtrToI(void * c_this);
extern void * nav_dtBVNode_IndexArray(void * c_this,long n);
extern void nav_dtLink_Delete(void * c_this);
extern void nav_dtLink_DeleteArray(void * c_this);
extern void* nav_NewdtLink();
extern void * nav_dtLink_GetPtrToBmax(void * c_this);
extern void * nav_dtLink_GetPtrToBmin(void * c_this);
extern void * nav_dtLink_GetPtrToEdge(void * c_this);
extern void * nav_dtLink_GetPtrToNext(void * c_this);
extern void * nav_dtLink_GetPtrToRef(void * c_this);
extern void * nav_dtLink_GetPtrToSide(void * c_this);
extern void * nav_dtLink_IndexArray(void * c_this,long n);
extern void nav_dtMeshHeader_Delete(void * c_this);
extern void nav_dtMeshHeader_DeleteArray(void * c_this);
extern void* nav_NewdtMeshHeader();
extern void * nav_dtMeshHeader_GetPtrToBmax(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToBmin(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToBvNodeCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToBvQuantFactor(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToDetailMeshCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToDetailTriCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToDetailVertCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToLayer(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToMagic(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToMaxLinkCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToOffMeshBase(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToOffMeshConCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToPolyCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToUserId(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToVersion(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToVertCount(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToWalkableClimb(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToWalkableHeight(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToWalkableRadius(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToX(void * c_this);
extern void * nav_dtMeshHeader_GetPtrToY(void * c_this);
extern void * nav_dtMeshHeader_IndexArray(void * c_this,long n);
extern void nav_dtMeshTile_Delete(void * c_this);
extern void nav_dtMeshTile_DeleteArray(void * c_this);
extern void * nav_dtMeshTile_GetPtrToBvTree(void * c_this);
extern void * nav_dtMeshTile_GetPtrToData(void * c_this);
extern void * nav_dtMeshTile_GetPtrToDataSize(void * c_this);
extern void * nav_dtMeshTile_GetPtrToDetailMeshes(void * c_this);
extern void * nav_dtMeshTile_GetPtrToDetailTris(void * c_this);
extern void * nav_dtMeshTile_GetPtrToDetailVerts(void * c_this);
extern void * nav_dtMeshTile_GetPtrToFlags(void * c_this);
extern void * nav_dtMeshTile_GetPtrToHeader(void * c_this);
extern void * nav_dtMeshTile_GetPtrToLinks(void * c_this);
extern void * nav_dtMeshTile_GetPtrToLinksFreeList(void * c_this);
extern void * nav_dtMeshTile_GetPtrToNext(void * c_this);
extern void * nav_dtMeshTile_GetPtrToOffMeshCons(void * c_this);
extern void * nav_dtMeshTile_GetPtrToPolys(void * c_this);
extern void * nav_dtMeshTile_GetPtrToSalt(void * c_this);
extern void * nav_dtMeshTile_GetPtrToVerts(void * c_this);
extern void * nav_dtMeshTile_IndexArray(void * c_this,long n);
extern unsigned int nav_dtNavMesh_addTile(void * c_this,void * data,int dataSize,int flags,unsigned int lastRef,void * result);
extern void nav_dtNavMesh_calcTileLoc(void * c_this,void * pos,void * tx,void * ty);
extern void nav_dtNavMesh_decodePolyId(void * c_this,unsigned int ref,void * salt,void * it,void * ip);
extern unsigned int nav_dtNavMesh_decodePolyIdPoly(void * c_this,unsigned int ref);
extern unsigned int nav_dtNavMesh_decodePolyIdSalt(void * c_this,unsigned int ref);
extern unsigned int nav_dtNavMesh_decodePolyIdTile(void * c_this,unsigned int ref);
extern void nav_dtNavMesh_Delete(void * c_this);
extern void nav_dtNavMesh_DeleteArray(void * c_this);
extern void* nav_NewdtNavMesh();
extern unsigned int nav_dtNavMesh_encodePolyId(void * c_this,unsigned int salt,unsigned int it,unsigned int ip);
extern int nav_dtNavMesh_getMaxTiles(void * c_this);
extern void * nav_dtNavMesh_getOffMeshConnectionByRef(void * c_this,unsigned int ref);
extern unsigned int nav_dtNavMesh_getOffMeshConnectionPolyEndPoints(void * c_this,unsigned int prevRef,unsigned int polyRef,void * startPos,void * endPos);
extern void * nav_dtNavMesh_getParams(void * c_this);
extern unsigned int nav_dtNavMesh_getPolyArea(void * c_this,unsigned int ref,void * resultArea);
extern unsigned int nav_dtNavMesh_getPolyFlags(void * c_this,unsigned int ref,void * resultFlags);
extern unsigned int nav_dtNavMesh_getPolyRefBase(void * c_this,void * tile);
extern void * nav_dtNavMesh_getTile(void * c_this,int i);
extern unsigned int nav_dtNavMesh_getTileAndPolyByRef(void * c_this,unsigned int ref,void * tile,void * poly);
extern void nav_dtNavMesh_getTileAndPolyByRefUnsafe(void * c_this,unsigned int ref,void * tile,void * poly);
extern void * nav_dtNavMesh_getTileAt(void * c_this,int x,int y,int layer);
extern void * nav_dtNavMesh_getTileByRef(void * c_this,unsigned int ref);
extern unsigned int nav_dtNavMesh_getTileRef(void * c_this,void * tile);
extern unsigned int nav_dtNavMesh_getTileRefAt(void * c_this,int x,int y,int layer);
extern int nav_dtNavMesh_getTilesAt(void * c_this,int x,int y,void * tiles,int maxTiles);
extern int nav_dtNavMesh_getTileStateSize(void * c_this,void * tile);
extern void * nav_dtNavMesh_IndexArray(void * c_this,long n);
extern unsigned int nav_dtNavMesh_init(void * c_this,void * params);
extern unsigned int nav_dtNavMesh_init11(void * c_this,void * data,int dataSize,int flags);
extern bool nav_dtNavMesh_isValidPolyRef(void * c_this,unsigned int ref);
extern unsigned int nav_dtNavMesh_removeTile(void * c_this,unsigned int ref,void * data,void * dataSize);
extern unsigned int nav_dtNavMesh_restoreTileState(void * c_this,void * tile,void * data,int maxDataSize);
extern unsigned int nav_dtNavMesh_setPolyArea(void * c_this,unsigned int ref,unsigned char area);
extern unsigned int nav_dtNavMesh_setPolyFlags(void * c_this,unsigned int ref,unsigned short flags);
extern unsigned int nav_dtNavMesh_storeTileState(void * c_this,void * tile,void * data,int maxDataSize);
extern void nav_dtNavMeshParams_Delete(void * c_this);
extern void nav_dtNavMeshParams_DeleteArray(void * c_this);
extern void* nav_NewdtNavMeshParams();
extern void * nav_dtNavMeshParams_GetPtrToMaxPolys(void * c_this);
extern void * nav_dtNavMeshParams_GetPtrToMaxTiles(void * c_this);
extern void * nav_dtNavMeshParams_GetPtrToOrig(void * c_this);
extern void * nav_dtNavMeshParams_GetPtrToTileHeight(void * c_this);
extern void * nav_dtNavMeshParams_GetPtrToTileWidth(void * c_this);
extern void * nav_dtNavMeshParams_IndexArray(void * c_this,long n);
extern void nav_dtOffMeshConnection_Delete(void * c_this);
extern void nav_dtOffMeshConnection_DeleteArray(void * c_this);
extern void* nav_NewdtOffMeshConnection();
extern void * nav_dtOffMeshConnection_GetPtrToFlags(void * c_this);
extern void * nav_dtOffMeshConnection_GetPtrToPoly(void * c_this);
extern void * nav_dtOffMeshConnection_GetPtrToPos(void * c_this);
extern void * nav_dtOffMeshConnection_GetPtrToRad(void * c_this);
extern void * nav_dtOffMeshConnection_GetPtrToSide(void * c_this);
extern void * nav_dtOffMeshConnection_GetPtrToUserId(void * c_this);
extern void * nav_dtOffMeshConnection_IndexArray(void * c_this,long n);
extern void nav_dtPoly_Delete(void * c_this);
extern void nav_dtPoly_DeleteArray(void * c_this);
extern void* nav_NewdtPoly();
extern unsigned char nav_dtPoly_getArea(void * c_this);
extern void * nav_dtPoly_GetPtrToAreaAndtype(void * c_this);
extern void * nav_dtPoly_GetPtrToFirstLink(void * c_this);
extern void * nav_dtPoly_GetPtrToFlags(void * c_this);
extern void * nav_dtPoly_GetPtrToNeis(void * c_this);
extern void * nav_dtPoly_GetPtrToVertCount(void * c_this);
extern void * nav_dtPoly_GetPtrToVerts(void * c_this);
extern unsigned char nav_dtPoly_getType(void * c_this);
extern void * nav_dtPoly_IndexArray(void * c_this,long n);
extern void nav_dtPoly_setArea(void * c_this,unsigned char a);
extern void nav_dtPoly_setType(void * c_this,unsigned char t);
extern void nav_dtPolyDetail_Delete(void * c_this);
extern void nav_dtPolyDetail_DeleteArray(void * c_this);
extern void* nav_NewdtPolyDetail();
extern void * nav_dtPolyDetail_GetPtrToTriBase(void * c_this);
extern void * nav_dtPolyDetail_GetPtrToTriCount(void * c_this);
extern void * nav_dtPolyDetail_GetPtrToVertBase(void * c_this);
extern void * nav_dtPolyDetail_GetPtrToVertCount(void * c_this);
extern void * nav_dtPolyDetail_IndexArray(void * c_this,long n);
extern void * nav_dtAllocNavMesh();
extern void nav_dtFreeNavMesh(void * navmesh);
extern int nav_dtGetDetailTriEdgeFlags(unsigned char triFlags,int edgeIndex);
extern void * nav_NewDtBVNodePtrArray(long n);
extern void * nav_NewDtLinkPtrArray(long n);
extern void * nav_NewDtMeshHeaderPtrArray(long n);
extern void * nav_NewDtNavMeshParamsPtrArray(long n);
extern void * nav_NewDtNavMeshPtrArray(long n);
extern void * nav_NewDtOffMeshConnectionPtrArray(long n);
extern void * nav_NewDtPolyDetailPtrArray(long n);
extern void * nav_NewDtPolyPtrArray(long n);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
Bounding volume node.

@note This structure is rarely if ever used by the end user.
@see dtMeshTile
*/
type DtBVNodePtr uintptr

/*
public void Delete()
*/
func (p DtBVNodePtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtBVNode_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtBVNodePtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtBVNode_DeleteArray(wrap_this)
}

/*
public dtBVNode()
*/
func NewDtBVNode() cgo.GoManagedPtr[DtBVNodePtr] {
	wrap_out := C.nav_NewdtBVNode()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtBVNodePtr]](uintptr(wrap_out))
	return go_out
}

/*
Maximum bounds of the node's AABB. [(x, y, z)]

public unsigned short(*)[3] GetPtrToBmax()
*/
func (p DtBVNodePtr) GetPtrToBmax() *[3]uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtBVNode_GetPtrToBmax(wrap_this)
	go_out := (*[3]uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Minimum bounds of the node's AABB. [(x, y, z)]

public unsigned short(*)[3] GetPtrToBmin()
*/
func (p DtBVNodePtr) GetPtrToBmin() *[3]uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtBVNode_GetPtrToBmin(wrap_this)
	go_out := (*[3]uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The node's index. (Negative for escape sequence.)

public int * GetPtrToI()
*/
func (p DtBVNodePtr) GetPtrToI() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtBVNode_GetPtrToI(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtBVNode * IndexArray(long n)
*/
func (p DtBVNodePtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtBVNode_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Defines a link between polygons.

@note This structure is rarely if ever used by the end user.
@see dtMeshTile
*/
type DtLinkPtr uintptr

/*
public void Delete()
*/
func (p DtLinkPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtLink_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtLinkPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtLink_DeleteArray(wrap_this)
}

/*
public dtLink()
*/
func NewDtLink() cgo.GoManagedPtr[DtLinkPtr] {
	wrap_out := C.nav_NewdtLink()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtLinkPtr]](uintptr(wrap_out))
	return go_out
}

/*
If a boundary link, defines the maximum sub-edge area.

public unsigned char * GetPtrToBmax()
*/
func (p DtLinkPtr) GetPtrToBmax() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToBmax(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
If a boundary link, defines the minimum sub-edge area.

public unsigned char * GetPtrToBmin()
*/
func (p DtLinkPtr) GetPtrToBmin() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToBmin(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Index of the polygon edge that owns this link.

public unsigned char * GetPtrToEdge()
*/
func (p DtLinkPtr) GetPtrToEdge() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToEdge(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Index of the next link.

public unsigned int * GetPtrToNext()
*/
func (p DtLinkPtr) GetPtrToNext() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToNext(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Neighbour reference. (The neighbor that is linked to.)

public dtPolyRef * GetPtrToRef()
*/
func (p DtLinkPtr) GetPtrToRef() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToRef(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
If a boundary link, defines on which side the link is.

public unsigned char * GetPtrToSide()
*/
func (p DtLinkPtr) GetPtrToSide() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_GetPtrToSide(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtLink * IndexArray(long n)
*/
func (p DtLinkPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtLink_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Provides high level information related to a dtMeshTile object.

	detour
*/
type DtMeshHeaderPtr uintptr

/*
public void Delete()
*/
func (p DtMeshHeaderPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtMeshHeader_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtMeshHeaderPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtMeshHeader_DeleteArray(wrap_this)
}

/*
public dtMeshHeader()
*/
func NewDtMeshHeader() cgo.GoManagedPtr[DtMeshHeaderPtr] {
	wrap_out := C.nav_NewdtMeshHeader()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtMeshHeaderPtr]](uintptr(wrap_out))
	return go_out
}

/*
The maximum bounds of the tile's AABB. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p DtMeshHeaderPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds of the tile's AABB. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p DtMeshHeaderPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of bounding volume nodes. (Zero if bounding volumes are disabled.)

public int * GetPtrToBvNodeCount()
*/
func (p DtMeshHeaderPtr) GetPtrToBvNodeCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToBvNodeCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The bounding volume quantization factor.

public float * GetPtrToBvQuantFactor()
*/
func (p DtMeshHeaderPtr) GetPtrToBvQuantFactor() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToBvQuantFactor(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of sub-meshes in the detail mesh.

public int * GetPtrToDetailMeshCount()
*/
func (p DtMeshHeaderPtr) GetPtrToDetailMeshCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToDetailMeshCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of triangles in the detail mesh.

public int * GetPtrToDetailTriCount()
*/
func (p DtMeshHeaderPtr) GetPtrToDetailTriCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToDetailTriCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of unique vertices in the detail mesh. (In addition to the polygon vertices.)

public int * GetPtrToDetailVertCount()
*/
func (p DtMeshHeaderPtr) GetPtrToDetailVertCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToDetailVertCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The layer of the tile within the dtNavMesh tile grid. (x, y, layer)

public int * GetPtrToLayer()
*/
func (p DtMeshHeaderPtr) GetPtrToLayer() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToLayer(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Tile magic number. (Used to identify the data format.)

public int * GetPtrToMagic()
*/
func (p DtMeshHeaderPtr) GetPtrToMagic() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToMagic(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of allocated links.

public int * GetPtrToMaxLinkCount()
*/
func (p DtMeshHeaderPtr) GetPtrToMaxLinkCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToMaxLinkCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The index of the first polygon which is an off-mesh connection.

public int * GetPtrToOffMeshBase()
*/
func (p DtMeshHeaderPtr) GetPtrToOffMeshBase() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToOffMeshBase(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of off-mesh connections.

public int * GetPtrToOffMeshConCount()
*/
func (p DtMeshHeaderPtr) GetPtrToOffMeshConCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToOffMeshConCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of polygons in the tile.

public int * GetPtrToPolyCount()
*/
func (p DtMeshHeaderPtr) GetPtrToPolyCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToPolyCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The user defined id of the tile.

public unsigned int * GetPtrToUserId()
*/
func (p DtMeshHeaderPtr) GetPtrToUserId() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToUserId(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Tile data format version number.

public int * GetPtrToVersion()
*/
func (p DtMeshHeaderPtr) GetPtrToVersion() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToVersion(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in the tile.

public int * GetPtrToVertCount()
*/
func (p DtMeshHeaderPtr) GetPtrToVertCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToVertCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum climb height of the agents using the tile.

public float * GetPtrToWalkableClimb()
*/
func (p DtMeshHeaderPtr) GetPtrToWalkableClimb() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToWalkableClimb(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the agents using the tile.

public float * GetPtrToWalkableHeight()
*/
func (p DtMeshHeaderPtr) GetPtrToWalkableHeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToWalkableHeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The radius of the agents using the tile.

public float * GetPtrToWalkableRadius()
*/
func (p DtMeshHeaderPtr) GetPtrToWalkableRadius() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToWalkableRadius(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The x-position of the tile within the dtNavMesh tile grid. (x, y, layer)

public int * GetPtrToX()
*/
func (p DtMeshHeaderPtr) GetPtrToX() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToX(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The y-position of the tile within the dtNavMesh tile grid. (x, y, layer)

public int * GetPtrToY()
*/
func (p DtMeshHeaderPtr) GetPtrToY() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_GetPtrToY(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtMeshHeader * IndexArray(long n)
*/
func (p DtMeshHeaderPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshHeader_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Defines a navigation mesh tile.

	detour
*/
type DtMeshTilePtr uintptr

/*
public void Delete()
*/
func (p DtMeshTilePtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtMeshTile_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtMeshTilePtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtMeshTile_DeleteArray(wrap_this)
}

/*
The tile bounding volume nodes. [Size: dtMeshHeader::bvNodeCount]
(Will be null if bounding volumes are disabled.)

public dtBVNode * * GetPtrToBvTree()
*/
func (p DtMeshTilePtr) GetPtrToBvTree() *DtBVNodePtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToBvTree(wrap_this)
	go_out := (*DtBVNodePtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile data. (Not directly accessed under normal situations.)

public unsigned char * * GetPtrToData()
*/
func (p DtMeshTilePtr) GetPtrToData() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToData(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Size of the tile data.

public int * GetPtrToDataSize()
*/
func (p DtMeshTilePtr) GetPtrToDataSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToDataSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile's detail sub-meshes. [Size: dtMeshHeader::detailMeshCount]

public dtPolyDetail * * GetPtrToDetailMeshes()
*/
func (p DtMeshTilePtr) GetPtrToDetailMeshes() *DtPolyDetailPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToDetailMeshes(wrap_this)
	go_out := (*DtPolyDetailPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The detail mesh's triangles. [(vertA, vertB, vertC, triFlags) * dtMeshHeader::detailTriCount].
See dtDetailTriEdgeFlags and dtGetDetailTriEdgeFlags.

public unsigned char * * GetPtrToDetailTris()
*/
func (p DtMeshTilePtr) GetPtrToDetailTris() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToDetailTris(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The detail mesh's unique vertices. [(x, y, z) * dtMeshHeader::detailVertCount]

public float * * GetPtrToDetailVerts()
*/
func (p DtMeshTilePtr) GetPtrToDetailVerts() **float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToDetailVerts(wrap_this)
	go_out := (**float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Tile flags. (See: #dtTileFlags)

public int * GetPtrToFlags()
*/
func (p DtMeshTilePtr) GetPtrToFlags() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToFlags(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile header.

public dtMeshHeader * * GetPtrToHeader()
*/
func (p DtMeshTilePtr) GetPtrToHeader() *DtMeshHeaderPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToHeader(wrap_this)
	go_out := (*DtMeshHeaderPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile links. [Size: dtMeshHeader::maxLinkCount]

public dtLink * * GetPtrToLinks()
*/
func (p DtMeshTilePtr) GetPtrToLinks() *DtLinkPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToLinks(wrap_this)
	go_out := (*DtLinkPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Index to the next free link.

public unsigned int * GetPtrToLinksFreeList()
*/
func (p DtMeshTilePtr) GetPtrToLinksFreeList() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToLinksFreeList(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The next free tile, or the next tile in the spatial grid.

public dtMeshTile * * GetPtrToNext()
*/
func (p DtMeshTilePtr) GetPtrToNext() *DtMeshTilePtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToNext(wrap_this)
	go_out := (*DtMeshTilePtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile off-mesh connections. [Size: dtMeshHeader::offMeshConCount]

public dtOffMeshConnection * * GetPtrToOffMeshCons()
*/
func (p DtMeshTilePtr) GetPtrToOffMeshCons() *DtOffMeshConnectionPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToOffMeshCons(wrap_this)
	go_out := (*DtOffMeshConnectionPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile polygons. [Size: dtMeshHeader::polyCount]

public dtPoly * * GetPtrToPolys()
*/
func (p DtMeshTilePtr) GetPtrToPolys() *DtPolyPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToPolys(wrap_this)
	go_out := (*DtPolyPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Counter describing modifications to the tile.

public unsigned int * GetPtrToSalt()
*/
func (p DtMeshTilePtr) GetPtrToSalt() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToSalt(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The tile vertices. [(x, y, z) * dtMeshHeader::vertCount]

public float * * GetPtrToVerts()
*/
func (p DtMeshTilePtr) GetPtrToVerts() **float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_GetPtrToVerts(wrap_this)
	go_out := (**float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtMeshTile * IndexArray(long n)
*/
func (p DtMeshTilePtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtMeshTile_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
A navigation mesh based on tiles of convex polygons.

	detour
*/
type DtNavMeshPtr uintptr

/*
Adds a tile to the navigation mesh.

@param data Data for the new tile mesh. (See: #dtCreateNavMeshData)
@param dataSize Data size of the new tile mesh.
@param flags Tile flags. (See: #dtTileFlags)
@param lastRef The desired reference for the tile. (When reloading a tile.) [opt] [Default: 0]
@param result The tile reference. (If the tile was succesfully added.) [opt]
@return The status flags for the operation.

public dtStatus addTile(unsigned char * data, int dataSize, int flags, dtTileRef lastRef, dtTileRef * result)
*/
func (p DtNavMeshPtr) AddTile(data *uint8, dataSize int32, flags int32, lastRef uint32, result *uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize C.int
	var wrap_arg_flags C.int
	var wrap_arg_lastRef C.uint
	var wrap_arg_result unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (C.int)(dataSize)
	wrap_arg_flags = (C.int)(flags)
	wrap_arg_lastRef = (C.uint)(lastRef)
	wrap_arg_result = (unsafe.Pointer)(result)
	wrap_out := C.nav_dtNavMesh_addTile(wrap_this, wrap_arg_data, wrap_arg_dataSize, wrap_arg_flags, wrap_arg_lastRef, wrap_arg_result)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Calculates the tile grid location for the specified world position.

@param pos The world position for the query. [(x, y, z)]
@param tx The tile's x-location. (x, y)
@param ty The tile's y-location. (x, y)

public void calcTileLoc(float const * pos, int * tx, int * ty) const
*/
func (p DtNavMeshPtr) CalcTileLoc(pos *float32, tx *int32, ty *int32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_tx unsafe.Pointer
	var wrap_arg_ty unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_tx = (unsafe.Pointer)(tx)
	wrap_arg_ty = (unsafe.Pointer)(ty)
	C.nav_dtNavMesh_calcTileLoc(wrap_this, wrap_arg_pos, wrap_arg_tx, wrap_arg_ty)
}

/*
Decodes a standard polygon reference.

@note This function is generally meant for internal use only.
@param ref The polygon reference to decode.
@param salt The tile's salt value.
@param it The index of the tile.
@param ip The index of the polygon within the tile.
@see #encodePolyId

public void decodePolyId(dtPolyRef ref, unsigned int& salt, unsigned int& it, unsigned int& ip) const
*/
func (p DtNavMeshPtr) DecodePolyId(ref uint32, salt *uint32, it *uint32, ip *uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_salt unsafe.Pointer
	var wrap_arg_it unsafe.Pointer
	var wrap_arg_ip unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_salt = (unsafe.Pointer)(salt)
	wrap_arg_it = (unsafe.Pointer)(it)
	wrap_arg_ip = (unsafe.Pointer)(ip)
	C.nav_dtNavMesh_decodePolyId(wrap_this, wrap_arg_ref, wrap_arg_salt, wrap_arg_it, wrap_arg_ip)
}

/*
Extracts the polygon's index (within its tile) from the specified polygon reference.

@note This function is generally meant for internal use only.
@param ref The polygon reference.
@see #encodePolyId

public unsigned int decodePolyIdPoly(dtPolyRef ref) const
*/
func (p DtNavMeshPtr) DecodePolyIdPoly(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_decodePolyIdPoly(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Extracts a tile's salt value from the specified polygon reference.

@note This function is generally meant for internal use only.
@param ref The polygon reference.
@see #encodePolyId

public unsigned int decodePolyIdSalt(dtPolyRef ref) const
*/
func (p DtNavMeshPtr) DecodePolyIdSalt(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_decodePolyIdSalt(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Extracts the tile's index from the specified polygon reference.

@note This function is generally meant for internal use only.
@param ref The polygon reference.
@see #encodePolyId

public unsigned int decodePolyIdTile(dtPolyRef ref) const
*/
func (p DtNavMeshPtr) DecodePolyIdTile(ref uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_decodePolyIdTile(wrap_this, wrap_arg_ref)
	go_out := uint32(wrap_out)
	return go_out
}

/*
public void Delete()
*/
func (p DtNavMeshPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMesh_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtNavMeshPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMesh_DeleteArray(wrap_this)
}

/*
public dtNavMesh()
*/
func NewDtNavMesh() cgo.GoManagedPtr[DtNavMeshPtr] {
	wrap_out := C.nav_NewdtNavMesh()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtNavMeshPtr]](uintptr(wrap_out))
	return go_out
}

/*
Derives a standard polygon reference.

@note This function is generally meant for internal use only.
@param salt The tile's salt value.
@param it The index of the tile.
@param ip The index of the polygon within the tile.

public dtPolyRef encodePolyId(unsigned int salt, unsigned int it, unsigned int ip) const
*/
func (p DtNavMeshPtr) EncodePolyId(salt uint32, it uint32, ip uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_salt C.uint
	var wrap_arg_it C.uint
	var wrap_arg_ip C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_salt = (C.uint)(salt)
	wrap_arg_it = (C.uint)(it)
	wrap_arg_ip = (C.uint)(ip)
	wrap_out := C.nav_dtNavMesh_encodePolyId(wrap_this, wrap_arg_salt, wrap_arg_it, wrap_arg_ip)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The maximum number of tiles supported by the navigation mesh.

@return The maximum number of tiles supported by the navigation mesh.

public int getMaxTiles() const
*/
func (p DtNavMeshPtr) GetMaxTiles() int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMesh_getMaxTiles(wrap_this)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the specified off-mesh connection.

@param ref The polygon reference of the off-mesh connection.
@return The specified off-mesh connection, or null if the polygon reference is not valid.

public dtOffMeshConnection const * getOffMeshConnectionByRef(dtPolyRef ref) const
*/
func (p DtNavMeshPtr) GetOffMeshConnectionByRef(ref uint32) DtOffMeshConnectionPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_getOffMeshConnectionByRef(wrap_this, wrap_arg_ref)
	go_out := cgo.MakePtr[DtOffMeshConnectionPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the endpoints for an off-mesh connection, ordered by "direction of travel".

@param prevRef The reference of the polygon before the connection.
@param polyRef The reference of the off-mesh connection polygon.
@param startPos The start position of the off-mesh connection. [(x, y, z)]
@param endPos The end position of the off-mesh connection. [(x, y, z)]
@return The status flags for the operation.

public dtStatus getOffMeshConnectionPolyEndPoints(dtPolyRef prevRef, dtPolyRef polyRef, float * startPos, float * endPos) const
*/
func (p DtNavMeshPtr) GetOffMeshConnectionPolyEndPoints(prevRef uint32, polyRef uint32, startPos *float32, endPos *float32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_prevRef C.uint
	var wrap_arg_polyRef C.uint
	var wrap_arg_startPos unsafe.Pointer
	var wrap_arg_endPos unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_prevRef = (C.uint)(prevRef)
	wrap_arg_polyRef = (C.uint)(polyRef)
	wrap_arg_startPos = (unsafe.Pointer)(startPos)
	wrap_arg_endPos = (unsafe.Pointer)(endPos)
	wrap_out := C.nav_dtNavMesh_getOffMeshConnectionPolyEndPoints(wrap_this, wrap_arg_prevRef, wrap_arg_polyRef, wrap_arg_startPos, wrap_arg_endPos)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The navigation mesh initialization params.

public dtNavMeshParams const * getParams() const
*/
func (p DtNavMeshPtr) GetParams() DtNavMeshParamsPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMesh_getParams(wrap_this)
	go_out := cgo.MakePtr[DtNavMeshParamsPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the user defined area for the specified polygon.

@param ref The polygon reference.
@param resultArea The area id for the polygon.
@return The status flags for the operation.

public dtStatus getPolyArea(dtPolyRef ref, unsigned char * resultArea) const
*/
func (p DtNavMeshPtr) GetPolyArea(ref uint32, resultArea *uint8) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_resultArea unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_resultArea = (unsafe.Pointer)(resultArea)
	wrap_out := C.nav_dtNavMesh_getPolyArea(wrap_this, wrap_arg_ref, wrap_arg_resultArea)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the user defined flags for the specified polygon.

@param ref The polygon reference.
@param resultFlags The polygon flags.
@return The status flags for the operation.

public dtStatus getPolyFlags(dtPolyRef ref, unsigned short * resultFlags) const
*/
func (p DtNavMeshPtr) GetPolyFlags(ref uint32, resultFlags *uint16) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_resultFlags unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_resultFlags = (unsafe.Pointer)(resultFlags)
	wrap_out := C.nav_dtNavMesh_getPolyFlags(wrap_this, wrap_arg_ref, wrap_arg_resultFlags)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the polygon reference for the tile's base polygon.

@param tile The tile.
@return The polygon reference for the base polygon in the specified tile.

public dtPolyRef getPolyRefBase(dtMeshTile const * tile) const
*/
func (p DtNavMeshPtr) GetPolyRefBase(tile DtMeshTilePtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_out := C.nav_dtNavMesh_getPolyRefBase(wrap_this, wrap_arg_tile)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the tile at the specified index.

@param i The tile index. [Limit: 0 >= index
<
#getMaxTiles()]
@return The tile at the specified index.

public dtMeshTile const * getTile(int i) const
*/
func (p DtNavMeshPtr) GetTile(i int32) DtMeshTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtNavMesh_getTile(wrap_this, wrap_arg_i)
	go_out := cgo.MakePtr[DtMeshTilePtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the tile and polygon for the specified polygon reference.

@param ref The reference for the a polygon.
@param tile The tile containing the polygon.
@param poly The polygon.
@return The status flags for the operation.

public dtStatus getTileAndPolyByRef(dtPolyRef const ref, dtMeshTile const * * tile, dtPoly const * * poly) const
*/
func (p DtNavMeshPtr) GetTileAndPolyByRef(ref uint32, tile *DtMeshTilePtr, poly *DtPolyPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_poly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_poly = (unsafe.Pointer)(poly)
	wrap_out := C.nav_dtNavMesh_getTileAndPolyByRef(wrap_this, wrap_arg_ref, wrap_arg_tile, wrap_arg_poly)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Returns the tile and polygon for the specified polygon reference.

@param ref A known valid reference for a polygon.
@param tile The tile containing the polygon.
@param poly The polygon.

public void getTileAndPolyByRefUnsafe(dtPolyRef const ref, dtMeshTile const * * tile, dtPoly const * * poly) const
*/
func (p DtNavMeshPtr) GetTileAndPolyByRefUnsafe(ref uint32, tile *DtMeshTilePtr, poly *DtPolyPtr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_poly unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_poly = (unsafe.Pointer)(poly)
	C.nav_dtNavMesh_getTileAndPolyByRefUnsafe(wrap_this, wrap_arg_ref, wrap_arg_tile, wrap_arg_poly)
}

/*
Gets the tile at the specified grid location.

@param x The tile's x-location. (x, y, layer)
@param y The tile's y-location. (x, y, layer)
@param layer The tile's layer. (x, y, layer)
@return The tile, or null if the tile does not exist.

public dtMeshTile const * getTileAt(int const x, int const y, int const layer) const
*/
func (p DtNavMeshPtr) GetTileAt(x int32, y int32, layer int32) DtMeshTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.int
	var wrap_arg_y C.int
	var wrap_arg_layer C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.int)(x)
	wrap_arg_y = (C.int)(y)
	wrap_arg_layer = (C.int)(layer)
	wrap_out := C.nav_dtNavMesh_getTileAt(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_layer)
	go_out := cgo.MakePtr[DtMeshTilePtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the tile for the specified tile reference.

@param ref The tile reference of the tile to retrieve.
@return The tile for the specified reference, or null if the
reference is invalid.

public dtMeshTile const * getTileByRef(dtTileRef ref) const
*/
func (p DtNavMeshPtr) GetTileByRef(ref uint32) DtMeshTilePtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_getTileByRef(wrap_this, wrap_arg_ref)
	go_out := cgo.MakePtr[DtMeshTilePtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the tile reference for the specified tile.

@param tile The tile.
@return The tile reference of the tile.

public dtTileRef getTileRef(dtMeshTile const * tile) const
*/
func (p DtNavMeshPtr) GetTileRef(tile DtMeshTilePtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_out := C.nav_dtNavMesh_getTileRef(wrap_this, wrap_arg_tile)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets the tile reference for the tile at specified grid location.

@param x The tile's x-location. (x, y, layer)
@param y The tile's y-location. (x, y, layer)
@param layer The tile's layer. (x, y, layer)
@return The tile reference of the tile, or 0 if there is none.

public dtTileRef getTileRefAt(int x, int y, int layer) const
*/
func (p DtNavMeshPtr) GetTileRefAt(x int32, y int32, layer int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.int
	var wrap_arg_y C.int
	var wrap_arg_layer C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.int)(x)
	wrap_arg_y = (C.int)(y)
	wrap_arg_layer = (C.int)(layer)
	wrap_out := C.nav_dtNavMesh_getTileRefAt(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_layer)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Gets all tiles at the specified grid location. (All layers.)

@param x The tile's x-location. (x, y)
@param y The tile's y-location. (x, y)
@param tiles A pointer to an array of tiles that will hold the result.
@param maxTiles The maximum tiles the tiles parameter can hold.
@return The number of tiles returned in the tiles array.

public int getTilesAt(int const x, int const y, dtMeshTile const * * tiles, int const maxTiles) const
*/
func (p DtNavMeshPtr) GetTilesAt(x int32, y int32, tiles *DtMeshTilePtr, maxTiles int32) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.int
	var wrap_arg_y C.int
	var wrap_arg_tiles unsafe.Pointer
	var wrap_arg_maxTiles C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.int)(x)
	wrap_arg_y = (C.int)(y)
	wrap_arg_tiles = (unsafe.Pointer)(tiles)
	wrap_arg_maxTiles = (C.int)(maxTiles)
	wrap_out := C.nav_dtNavMesh_getTilesAt(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_tiles, wrap_arg_maxTiles)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the size of the buffer required by #storeTileState to store the specified tile's state.

@param tile The tile.
@return The size of the buffer required to store the state.

public int getTileStateSize(dtMeshTile const * tile) const
*/
func (p DtNavMeshPtr) GetTileStateSize(tile DtMeshTilePtr) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_out := C.nav_dtNavMesh_getTileStateSize(wrap_this, wrap_arg_tile)
	go_out := int32(wrap_out)
	return go_out
}

/*
dtNavMesh * IndexArray(long n)
*/
func (p DtNavMeshPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMesh_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Initializes the navigation mesh for tiled use.

@param params Initialization parameters.
@return The status flags for the operation.

public dtStatus init(dtNavMeshParams const * params)
*/
func (p DtNavMeshPtr) Init(params DtNavMeshParamsPtr) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_params unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_params = (unsafe.Pointer)(params)
	wrap_out := C.nav_dtNavMesh_init(wrap_this, wrap_arg_params)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Initializes the navigation mesh for single tile use.

@param data Data of the new tile. (See: #dtCreateNavMeshData)
@param dataSize The data size of the new tile.
@param flags The tile flags. (See: #dtTileFlags)
@return The status flags for the operation.
@see dtCreateNavMeshData

public dtStatus init(unsigned char * data, int const dataSize, int const flags)
*/
func (p DtNavMeshPtr) Init11(data *uint8, dataSize int32, flags int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize C.int
	var wrap_arg_flags C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (C.int)(dataSize)
	wrap_arg_flags = (C.int)(flags)
	wrap_out := C.nav_dtNavMesh_init11(wrap_this, wrap_arg_data, wrap_arg_dataSize, wrap_arg_flags)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Checks the validity of a polygon reference.

@param ref The polygon reference to check.
@return True if polygon reference is valid for the navigation mesh.

public bool isValidPolyRef(dtPolyRef ref) const
*/
func (p DtNavMeshPtr) IsValidPolyRef(ref uint32) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_out := C.nav_dtNavMesh_isValidPolyRef(wrap_this, wrap_arg_ref)
	go_out := bool(wrap_out)
	return go_out
}

/*
Removes the specified tile from the navigation mesh.

@param ref The reference of the tile to remove.
@param data Data associated with deleted tile.
@param dataSize Size of the data associated with deleted tile.
@return The status flags for the operation.

public dtStatus removeTile(dtTileRef ref, unsigned char * * data, int * dataSize)
*/
func (p DtNavMeshPtr) RemoveTile(ref uint32, data **uint8, dataSize *int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_dataSize unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_dataSize = (unsafe.Pointer)(dataSize)
	wrap_out := C.nav_dtNavMesh_removeTile(wrap_this, wrap_arg_ref, wrap_arg_data, wrap_arg_dataSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Restores the state of the tile.

@param tile The tile.
@param data The new state. (Obtained from #storeTileState.)
@param maxDataSize The size of the state within the data buffer.
@return The status flags for the operation.

public dtStatus restoreTileState(dtMeshTile * tile, unsigned char const * data, int const maxDataSize)
*/
func (p DtNavMeshPtr) RestoreTileState(tile DtMeshTilePtr, data *uint8, maxDataSize int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_maxDataSize C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_maxDataSize = (C.int)(maxDataSize)
	wrap_out := C.nav_dtNavMesh_restoreTileState(wrap_this, wrap_arg_tile, wrap_arg_data, wrap_arg_maxDataSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Sets the user defined area for the specified polygon.

@param ref The polygon reference.
@param area The new area id for the polygon. [Limit:
<
#DT_MAX_AREAS]
@return The status flags for the operation.

public dtStatus setPolyArea(dtPolyRef ref, unsigned char area)
*/
func (p DtNavMeshPtr) SetPolyArea(ref uint32, area uint8) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_area C.uchar
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_area = (C.uchar)(area)
	wrap_out := C.nav_dtNavMesh_setPolyArea(wrap_this, wrap_arg_ref, wrap_arg_area)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Sets the user defined flags for the specified polygon.

@param ref The polygon reference.
@param flags The new flags for the polygon.
@return The status flags for the operation.

public dtStatus setPolyFlags(dtPolyRef ref, unsigned short flags)
*/
func (p DtNavMeshPtr) SetPolyFlags(ref uint32, flags uint16) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_ref C.uint
	var wrap_arg_flags C.ushort
	wrap_this = unsafe.Pointer(p)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_flags = (C.ushort)(flags)
	wrap_out := C.nav_dtNavMesh_setPolyFlags(wrap_this, wrap_arg_ref, wrap_arg_flags)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Stores the non-structural state of the tile in the specified buffer. (Flags, area ids, etc.)

@param tile The tile.
@param data The buffer to store the tile's state in.
@param maxDataSize The size of the data buffer. [Limit: >= #getTileStateSize]
@return The status flags for the operation.

public dtStatus storeTileState(dtMeshTile const * tile, unsigned char * data, int const maxDataSize) const
*/
func (p DtNavMeshPtr) StoreTileState(tile DtMeshTilePtr, data *uint8, maxDataSize int32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_tile unsafe.Pointer
	var wrap_arg_data unsafe.Pointer
	var wrap_arg_maxDataSize C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_tile = (unsafe.Pointer)(tile)
	wrap_arg_data = (unsafe.Pointer)(data)
	wrap_arg_maxDataSize = (C.int)(maxDataSize)
	wrap_out := C.nav_dtNavMesh_storeTileState(wrap_this, wrap_arg_tile, wrap_arg_data, wrap_arg_maxDataSize)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Configuration parameters used to define multi-tile navigation meshes.
The values are used to allocate space during the initialization of a navigation mesh.

@see dtNavMesh::init()

	detour
*/
type DtNavMeshParamsPtr uintptr

/*
public void Delete()
*/
func (p DtNavMeshParamsPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMeshParams_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtNavMeshParamsPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtNavMeshParams_DeleteArray(wrap_this)
}

/*
public dtNavMeshParams()
*/
func NewDtNavMeshParams() cgo.GoManagedPtr[DtNavMeshParamsPtr] {
	wrap_out := C.nav_NewdtNavMeshParams()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtNavMeshParamsPtr]](uintptr(wrap_out))
	return go_out
}

/*
The maximum number of polygons each tile can contain. This and maxTiles are used to calculate how many bits are needed to identify tiles and polygons uniquely.

public int * GetPtrToMaxPolys()
*/
func (p DtNavMeshParamsPtr) GetPtrToMaxPolys() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_GetPtrToMaxPolys(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum number of tiles the navigation mesh can contain. This and maxPolys are used to calculate how many bits are needed to identify tiles and polygons uniquely.

public int * GetPtrToMaxTiles()
*/
func (p DtNavMeshParamsPtr) GetPtrToMaxTiles() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_GetPtrToMaxTiles(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The world space origin of the navigation mesh's tile space. [(x, y, z)]

public float(*)[3] GetPtrToOrig()
*/
func (p DtNavMeshParamsPtr) GetPtrToOrig() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_GetPtrToOrig(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each tile. (Along the z-axis.)

public float * GetPtrToTileHeight()
*/
func (p DtNavMeshParamsPtr) GetPtrToTileHeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_GetPtrToTileHeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of each tile. (Along the x-axis.)

public float * GetPtrToTileWidth()
*/
func (p DtNavMeshParamsPtr) GetPtrToTileWidth() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_GetPtrToTileWidth(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtNavMeshParams * IndexArray(long n)
*/
func (p DtNavMeshParamsPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtNavMeshParams_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Defines an navigation mesh off-mesh connection within a dtMeshTile object.
An off-mesh connection is a user defined traversable connection made up to two vertices.
*/
type DtOffMeshConnectionPtr uintptr

/*
public void Delete()
*/
func (p DtOffMeshConnectionPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtOffMeshConnection_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtOffMeshConnectionPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtOffMeshConnection_DeleteArray(wrap_this)
}

/*
public dtOffMeshConnection()
*/
func NewDtOffMeshConnection() cgo.GoManagedPtr[DtOffMeshConnectionPtr] {
	wrap_out := C.nav_NewdtOffMeshConnection()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtOffMeshConnectionPtr]](uintptr(wrap_out))
	return go_out
}

/*
Link flags.

@note These are not the connection's user defined flags. Those are assigned via the
connection's dtPoly definition. These are link flags used for internal purposes.

public unsigned char * GetPtrToFlags()
*/
func (p DtOffMeshConnectionPtr) GetPtrToFlags() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToFlags(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The polygon reference of the connection within the tile.

public unsigned short * GetPtrToPoly()
*/
func (p DtOffMeshConnectionPtr) GetPtrToPoly() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToPoly(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The endpoints of the connection. [(ax, ay, az, bx, by, bz)]

public float(*)[6] GetPtrToPos()
*/
func (p DtOffMeshConnectionPtr) GetPtrToPos() *[6]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToPos(wrap_this)
	go_out := (*[6]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The radius of the endpoints. [Limit: >= 0]

public float * GetPtrToRad()
*/
func (p DtOffMeshConnectionPtr) GetPtrToRad() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToRad(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
End point side.

public unsigned char * GetPtrToSide()
*/
func (p DtOffMeshConnectionPtr) GetPtrToSide() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToSide(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The id of the offmesh connection. (User assigned when the navigation mesh is built.)

public unsigned int * GetPtrToUserId()
*/
func (p DtOffMeshConnectionPtr) GetPtrToUserId() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_GetPtrToUserId(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtOffMeshConnection * IndexArray(long n)
*/
func (p DtOffMeshConnectionPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtOffMeshConnection_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Defines a polygon within a dtMeshTile object.

	detour
*/
type DtPolyPtr uintptr

/*
public void Delete()
*/
func (p DtPolyPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtPoly_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtPolyPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtPoly_DeleteArray(wrap_this)
}

/*
public dtPoly()
*/
func NewDtPoly() cgo.GoManagedPtr[DtPolyPtr] {
	wrap_out := C.nav_NewdtPoly()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtPolyPtr]](uintptr(wrap_out))
	return go_out
}

/*
Gets the user defined area id.

public unsigned char getArea() const
*/
func (p DtPolyPtr) GetArea() uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_getArea(wrap_this)
	go_out := uint8(wrap_out)
	return go_out
}

/*
The bit packed area id and polygon type.

@note Use the structure's set and get methods to access this value.

public unsigned char * GetPtrToAreaAndtype()
*/
func (p DtPolyPtr) GetPtrToAreaAndtype() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToAreaAndtype(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Index to first link in linked list. (Or #DT_NULL_LINK if there is no link.)

public unsigned int * GetPtrToFirstLink()
*/
func (p DtPolyPtr) GetPtrToFirstLink() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToFirstLink(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The user defined polygon flags.

public unsigned short * GetPtrToFlags()
*/
func (p DtPolyPtr) GetPtrToFlags() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToFlags(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Packed data representing neighbor polygons references and flags for each edge.

public unsigned short(*)[6] GetPtrToNeis()
*/
func (p DtPolyPtr) GetPtrToNeis() *[6]uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToNeis(wrap_this)
	go_out := (*[6]uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in the polygon.

public unsigned char * GetPtrToVertCount()
*/
func (p DtPolyPtr) GetPtrToVertCount() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToVertCount(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The indices of the polygon's vertices.
The actual vertices are located in dtMeshTile::verts.

public unsigned short(*)[6] GetPtrToVerts()
*/
func (p DtPolyPtr) GetPtrToVerts() *[6]uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_GetPtrToVerts(wrap_this)
	go_out := (*[6]uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Gets the polygon type. (See: #dtPolyTypes)

public unsigned char getType() const
*/
func (p DtPolyPtr) GetType() uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_getType(wrap_this)
	go_out := uint8(wrap_out)
	return go_out
}

/*
dtPoly * IndexArray(long n)
*/
func (p DtPolyPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPoly_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Sets the user defined area id. [Limit:
<
#DT_MAX_AREAS]

public void setArea(unsigned char a)
*/
func (p DtPolyPtr) SetArea(a uint8) {
	var wrap_this unsafe.Pointer
	var wrap_arg_a C.uchar
	wrap_this = unsafe.Pointer(p)
	wrap_arg_a = (C.uchar)(a)
	C.nav_dtPoly_setArea(wrap_this, wrap_arg_a)
}

/*
Sets the polygon type. (See: #dtPolyTypes.)

public void setType(unsigned char t)
*/
func (p DtPolyPtr) SetType(t uint8) {
	var wrap_this unsafe.Pointer
	var wrap_arg_t C.uchar
	wrap_this = unsafe.Pointer(p)
	wrap_arg_t = (C.uchar)(t)
	C.nav_dtPoly_setType(wrap_this, wrap_arg_t)
}

/*
Defines the location of detail sub-mesh data within a dtMeshTile.
*/
type DtPolyDetailPtr uintptr

/*
public void Delete()
*/
func (p DtPolyDetailPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtPolyDetail_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtPolyDetailPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtPolyDetail_DeleteArray(wrap_this)
}

/*
public dtPolyDetail()
*/
func NewDtPolyDetail() cgo.GoManagedPtr[DtPolyDetailPtr] {
	wrap_out := C.nav_NewdtPolyDetail()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtPolyDetailPtr]](uintptr(wrap_out))
	return go_out
}

/*
The offset of the triangles in the dtMeshTile::detailTris array.

public unsigned int * GetPtrToTriBase()
*/
func (p DtPolyDetailPtr) GetPtrToTriBase() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPolyDetail_GetPtrToTriBase(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of triangles in the sub-mesh.

public unsigned char * GetPtrToTriCount()
*/
func (p DtPolyDetailPtr) GetPtrToTriCount() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPolyDetail_GetPtrToTriCount(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The offset of the vertices in the dtMeshTile::detailVerts array.

public unsigned int * GetPtrToVertBase()
*/
func (p DtPolyDetailPtr) GetPtrToVertBase() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPolyDetail_GetPtrToVertBase(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in the sub-mesh.

public unsigned char * GetPtrToVertCount()
*/
func (p DtPolyDetailPtr) GetPtrToVertCount() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPolyDetail_GetPtrToVertCount(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtPolyDetail * IndexArray(long n)
*/
func (p DtPolyDetailPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtPolyDetail_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Allocates a navigation mesh object using the Detour allocator.

@return A navigation mesh that is ready for initialization, or null on failure.

	detour

dtNavMesh * dtAllocNavMesh()
*/
func DtAllocNavMesh() DtNavMeshPtr {
	wrap_out := C.nav_dtAllocNavMesh()
	go_out := cgo.MakePtr[DtNavMeshPtr](uintptr(wrap_out))
	return go_out
}

/*
Frees the specified navigation mesh object using the Detour allocator.

@param navmesh A navigation mesh allocated using #dtAllocNavMesh

	detour

void dtFreeNavMesh(dtNavMesh * navmesh)
*/
func DtFreeNavMesh(navmesh DtNavMeshPtr) {
	var wrap_arg_navmesh unsafe.Pointer
	wrap_arg_navmesh = (unsafe.Pointer)(navmesh)
	C.nav_dtFreeNavMesh(wrap_arg_navmesh)
}

/*
Get flags for edge in detail triangle.

@param triFlags The flags for the triangle (last component of detail vertices above).
@param edgeIndex The index of the first vertex of the edge. For instance, if 0,
returns flags for edge AB.

int dtGetDetailTriEdgeFlags(unsigned char triFlags, int edgeIndex)
*/
func DtGetDetailTriEdgeFlags(triFlags uint8, edgeIndex int32) int32 {
	var wrap_arg_triFlags C.uchar
	var wrap_arg_edgeIndex C.int
	wrap_arg_triFlags = (C.uchar)(triFlags)
	wrap_arg_edgeIndex = (C.int)(edgeIndex)
	wrap_out := C.nav_dtGetDetailTriEdgeFlags(wrap_arg_triFlags, wrap_arg_edgeIndex)
	go_out := int32(wrap_out)
	return go_out
}

/*
dtBVNode * NewDtBVNodePtrArray(long n)
*/
func NewDtBVNodePtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtBVNodePtr]] {
	wrap_out := C.nav_NewDtBVNodePtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtBVNodePtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtLink * NewDtLinkPtrArray(long n)
*/
func NewDtLinkPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtLinkPtr]] {
	wrap_out := C.nav_NewDtLinkPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtLinkPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtMeshHeader * NewDtMeshHeaderPtrArray(long n)
*/
func NewDtMeshHeaderPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtMeshHeaderPtr]] {
	wrap_out := C.nav_NewDtMeshHeaderPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtMeshHeaderPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtNavMeshParams * NewDtNavMeshParamsPtrArray(long n)
*/
func NewDtNavMeshParamsPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtNavMeshParamsPtr]] {
	wrap_out := C.nav_NewDtNavMeshParamsPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtNavMeshParamsPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtNavMesh * NewDtNavMeshPtrArray(long n)
*/
func NewDtNavMeshPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtNavMeshPtr]] {
	wrap_out := C.nav_NewDtNavMeshPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtNavMeshPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtOffMeshConnection * NewDtOffMeshConnectionPtrArray(long n)
*/
func NewDtOffMeshConnectionPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtOffMeshConnectionPtr]] {
	wrap_out := C.nav_NewDtOffMeshConnectionPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtOffMeshConnectionPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtPolyDetail * NewDtPolyDetailPtrArray(long n)
*/
func NewDtPolyDetailPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtPolyDetailPtr]] {
	wrap_out := C.nav_NewDtPolyDetailPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtPolyDetailPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtPoly * NewDtPolyPtrArray(long n)
*/
func NewDtPolyPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtPolyPtr]] {
	wrap_out := C.nav_NewDtPolyPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtPolyPtr]]](uintptr(wrap_out))
	return go_out
}

type EnumDtDetailTriEdgeFlags uint32

const (
	/*
	   Detail triangle edge is part of the poly boundary
	*/
	EnumDtDetailTriEdgeFlags_DT_DETAIL_EDGE_BOUNDARY EnumDtDetailTriEdgeFlags = 1
)

/*
Options for dtNavMeshQuery::initSlicedFindPath and updateSlicedFindPath
*/
type EnumDtFindPathOptions uint32

const (
	/*
	   use raycasts during pathfind to "shortcut" (raycast still consider costs)
	*/
	EnumDtFindPathOptions_DT_FINDPATH_ANY_ANGLE EnumDtFindPathOptions = 2
)

/*
Flags representing the type of a navigation mesh polygon.
*/
type EnumDtPolyTypes uint32

const (
	/*
	   The polygon is a standard convex polygon that is part of the surface of the mesh.
	*/
	EnumDtPolyTypes_DT_POLYTYPE_GROUND EnumDtPolyTypes = 0
	/*
	   The polygon is an off-mesh connection consisting of two vertices.
	*/
	EnumDtPolyTypes_DT_POLYTYPE_OFFMESH_CONNECTION EnumDtPolyTypes = 1
)

/*
Options for dtNavMeshQuery::raycast
*/
type EnumDtRaycastOptions uint32

const (
	/*
	   Raycast should calculate movement cost along the ray and fill RaycastHit::cost
	*/
	EnumDtRaycastOptions_DT_RAYCAST_USE_COSTS EnumDtRaycastOptions = 1
)

/*
Vertex flags returned by dtNavMeshQuery::findStraightPath.
*/
type EnumDtStraightPathFlags uint32

const (
	/*
	   The vertex is the start position in the path.
	*/
	EnumDtStraightPathFlags_DT_STRAIGHTPATH_START EnumDtStraightPathFlags = 1
	/*
	   The vertex is the end position in the path.
	*/
	EnumDtStraightPathFlags_DT_STRAIGHTPATH_END EnumDtStraightPathFlags = 2
	/*
	   The vertex is the start of an off-mesh connection.
	*/
	EnumDtStraightPathFlags_DT_STRAIGHTPATH_OFFMESH_CONNECTION EnumDtStraightPathFlags = 4
)

/*
Options for dtNavMeshQuery::findStraightPath.
*/
type EnumDtStraightPathOptions uint32

const (
	/*
	   Add a vertex at every polygon edge crossing where area changes.
	*/
	EnumDtStraightPathOptions_DT_STRAIGHTPATH_AREA_CROSSINGS EnumDtStraightPathOptions = 1
	/*
	   Add a vertex at every polygon edge crossing.
	*/
	EnumDtStraightPathOptions_DT_STRAIGHTPATH_ALL_CROSSINGS EnumDtStraightPathOptions = 2
)

/*
Tile flags used for various functions and fields.
For an example, see dtNavMesh::addTile().
*/
type EnumDtTileFlags uint32

const (
	/*
	   The navigation mesh owns the tile memory and is responsible for freeing it.
	*/
	EnumDtTileFlags_DT_TILE_FREE_DATA EnumDtTileFlags = 1
)
